home *** CD-ROM | disk | FTP | other *** search
/ FishMarket 1.0 / FishMarket v1.0.iso / fishies / 551-575 / disk_566 / foco / foco.c < prev    next >
C/C++ Source or Header  |  1992-05-06  |  21KB  |  848 lines
  1. /*
  2.  * FoCo: Formatier-Kontroll-Programm
  3.  *       (GadTools-Commodities-etc-Einführung)
  4.  *       Autor: Michael Balzer
  5.  * 
  6.  * 03/91: Erste Version (primär für MacSoft Highlights-Serie)
  7.  *        Version 1.0
  8.  * 
  9.  * 10/91: Änderung, Delay bevor Drivecheck durchgeführt wird
  10.  *        (stand schon lange an...) und Quit-Frage bei CloseWindow
  11.  *        Version 1.1
  12.  * 
  13.  */
  14.  
  15. #ifndef FOCO_HDR
  16. # include "FoCo.h"
  17. #endif
  18.  
  19. #include <dos/dosextens.h>
  20.  
  21. /*------------------------------------------------------------------------*/
  22. void ende(int, STRPTR);
  23. struct Gadget *CreateAllGadgets(struct Gadget **glistptr, 
  24.     void *vi, UWORD topborder);
  25. void ShowWindow( void );
  26. void HideWindow( void );
  27. int GetBADNum( void );
  28.  
  29. void ArgArrayDone( void );
  30. UBYTE **ArgArrayInit( LONG arg1, UBYTE **arg2 );
  31. LONG ArgInt( UBYTE **arg1, UBYTE *arg2, LONG arg3 );
  32. UBYTE *ArgString( UBYTE **arg1, UBYTE *arg2, UBYTE *arg3 );
  33. CxObj *HotKey( UBYTE *arg1, struct MsgPort *arg2, LONG arg3 );
  34.  
  35. LONG Printf( UBYTE *format, ... );
  36. LONG CSystem( UBYTE *command, LONG tag1, ... );
  37.  
  38. /*------------------------------------------------------------------*/
  39. /* GadgetIDs: */
  40. #define GAD_DRIVE        1
  41. #define GAD_NAME        2
  42. #define GAD_FFS            3
  43. #define GAD_NOICONS        4
  44. #define GAD_QUICK        5
  45. #define GAD_OK            6
  46. #define GAD_CANCEL        7
  47.  
  48. /*------------------------------------------------------------------------*/
  49. /*  Globale Variablen... */
  50. struct IntuitionBase        *IntuitionBase = NULL;
  51. struct GfxBase                *GfxBase = NULL;
  52. struct Library                *GadToolsBase = NULL;
  53. extern struct Library        *IconBase;
  54.  
  55. struct TextFont                *font = NULL;
  56. struct Screen                *mysc = NULL;
  57. struct Gadget                *glist = NULL;
  58. struct Window                *mywin = NULL;
  59.  
  60. void                        *vi = NULL;
  61. struct RastPort                *rp;
  62. int                            Xwidth, WinWidth, WinHeight;
  63. UWORD                        topborder;
  64. ULONG                        windowsignal=0;
  65.  
  66. STRPTR DiskList[5] = { NULL,NULL,NULL,NULL,NULL };
  67. STRPTR DiskName[4] = { "DF0:","DF1:","DF2:","DF3:" };
  68.  
  69. char *TextSpeicher = 0;
  70. #define _COUNT_TXT 15
  71. char *ProgrammText[ _COUNT_TXT ] =
  72. {
  73.     "Formatter",
  74.     "You just inserted an unreadable disk\n"
  75.     "in drive %s.\n"
  76.     "Do you want it to be formatted?",
  77.     " Yes |   NO!   ",
  78.     "User-friendly disk formatter",
  79.     "Pops up on disk insertion/hotkey",
  80.     "Drive:",
  81.     "Name:",
  82.     "FFS",
  83.     "NoIcons",
  84.     "Quick",
  85.     "Format!",
  86.     "Cancel!",
  87.     "Format Disk...",
  88.     "CON:0/0/512/83/Formatting Disk...",
  89.     "Quit FoCo?"
  90. };
  91. #define TXT(n) ProgrammText[n]
  92.  
  93. struct EasyStruct formatreq =
  94. {
  95.     sizeof( struct EasyStruct ), 0,
  96.     0, 0, 0
  97.     /*TXT(0), TXT(1), TXT(2)*/
  98. };
  99.  
  100. struct EasyStruct quitreq =
  101. {
  102.     sizeof( struct EasyStruct ), 0,
  103.     0, 0, 0
  104.     /*TXT(0), TXT(14), TXT(2)*/
  105. };
  106.  
  107. /*------------------------------------------------------------------------*/
  108. /* Trackdisk-Variablen */
  109.  
  110. struct IOExtTD                *ioexttd[4]={ 0,0,0,0 };
  111. int                            changenum[4];
  112. struct MsgPort                *tdport=0;
  113.  
  114. /*------------------------------------------------------------------------*/
  115. /*  Adressen der Gadgets, Status-Variablen */
  116.  
  117. struct Gadget *drivegad, *namegad, *ffsgad, *noiconsgad, *quickgad;
  118.  
  119. int drive;
  120. char name[33];
  121. BOOL bffs=TRUE, bnoicons=TRUE, bquick=FALSE;
  122.  
  123. /*------------------------------------------------------------------------*/
  124. /* Commodities-Variablen */
  125.  
  126. struct Library            *CxBase        = NULL;
  127. extern struct Library    *IconBase;
  128.  
  129. char                    **ttypes = NULL, *hotstr;
  130.  
  131. struct MsgPort            *cxport = 0;
  132. ULONG                    cxsigflag = 0;        /* signal for above */
  133.  
  134. CxObj                    *broker = NULL;        /* Our broker */
  135.  
  136. #define POP_KEY_ID (86L)                    /* pop up identifier */
  137.  
  138. struct NewBroker mynb = {
  139.     NB_VERSION,                        /* Library needs to know version */
  140.     0 /*TXT(0)*/,                    /* broker internal name             */
  141.     0 /*TXT(3)*/,                    /* commodity title                 */
  142.     0 /*TXT(4)*/,                    /* description                 */
  143.     NBU_NOTIFY | NBU_UNIQUE,        /* We want to be the only broker */
  144.                                     /* with this name and we want to */
  145.                                     /* be notified of any attempts     */
  146.                                     /* to add a commodity with the     */
  147.                                     /* same name                     */
  148.     COF_SHOW_HIDE,                    /* flags                         */
  149.     0,                                /* default priority                 */
  150.     NULL,                            /* port, will fill in             */
  151.     0                                /* channel (reserved)             */
  152. };
  153.  
  154. /* Eine "input expression" die auf DISK_INSERTED paßt */
  155.  
  156. IX diskix = {
  157.     IX_VERSION,                /* required */
  158.     IECLASS_DISKINSERTED,
  159.     0,                        /* Code   */
  160.     ~0,                        /* CodeMask   */
  161.     
  162.     0,                      /* qualifier I am interested in  */
  163.     0,
  164.     0                       /* synonyms irrelevant           */
  165. };
  166.  
  167. #define CX_DISK_ID (87L)
  168.  
  169. /*-------------------------------------------------------------------------*/
  170. /* Trackdisk-Support-Funktion(en) */
  171.  
  172. int GetChangeNum( int unit )
  173. {
  174.     if( !ioexttd[unit] ) return( 0 );
  175.     
  176.     ioexttd[unit]->iotd_Req.io_Command = TD_CHANGENUM;
  177.     DoIO( ioexttd[unit] );
  178.     return( ioexttd[unit]->iotd_Req.io_Actual );
  179. }
  180.  
  181. int GetBADNum( void )
  182. {
  183.     int result=-1, i, cn;
  184.     struct InfoData *infoData;
  185.     struct MsgPort *port;
  186.     
  187.     if( !(infoData = AllocMem(sizeof(struct InfoData),MEMF_PUBLIC)) )
  188.         return -1;
  189.     
  190.     /* ermitteln, WO eine Disk eingelegt wurde */
  191.     for( i=0; i<=3; i++ )
  192.     {
  193.         if( cn = GetChangeNum(i) )
  194.         {
  195.             if( (cn>changenum[i]) && (port=DeviceProc(DiskName[i])) )
  196.             {
  197.                 /* und ob die 'BAD' oder 'NDOS' ist */
  198.                 if( DoPkt( port, ACTION_DISK_INFO, MKBADDR(infoData), 0,0,0 ) )
  199.                 {
  200.                     if( infoData->id_DiskType == ID_UNREADABLE_DISK 
  201.                      || infoData->id_DiskType == ID_NOT_REALLY_DOS )
  202.                         result=i;
  203.                 }
  204.             }
  205.             
  206.             changenum[i] = cn;
  207.         }
  208.     }
  209.     
  210.     FreeMem( infoData, sizeof(struct InfoData) );
  211.     return( result );
  212. }
  213.  
  214. /*-------------------------------------------------------------------------*/
  215.  
  216. void LiesProgrammTexte( char *filename )
  217. {
  218.     BPTR file;
  219.     long size, i;
  220.     char *ts;
  221.     
  222.     if( file=Open(filename,MODE_OLDFILE) )
  223.     {
  224.         size = Seek( file, Seek(file,0,OFFSET_END), OFFSET_BEGINNING );
  225.         if( TextSpeicher=AllocMem(size+4,MEMF_PUBLIC) )
  226.         {
  227.             *((long *)TextSpeicher) = size+4;
  228.             Read( file, TextSpeicher+4, size );
  229.             for( i=0, ts=TextSpeicher+4; i < _COUNT_TXT; i++, ts+=strlen(ts)+1 )
  230.                 ProgrammText[i] = ts;
  231.         }
  232.         Close( file );
  233.     }
  234. }
  235.  
  236. void InitAll( int argc, char **argv )
  237. {
  238.     char *str;
  239.     CxObj *cxo;
  240.     int i, dr=0;
  241.     
  242.             /*** Libraries öffnen... ***/
  243.     
  244.     if (!(GfxBase = (struct GfxBase *)
  245.         OpenLibrary("graphics.library", 36L)))
  246.         ende(20, "Requires V36 graphics.library");
  247.  
  248.     if (!(IntuitionBase = (struct IntuitionBase *)
  249.         OpenLibrary("intuition.library", 36L)))
  250.         ende(20, "Requires V36 intuition.library");
  251.  
  252.     if (!(GadToolsBase = OpenLibrary("gadtools.library", 36L)))
  253.         ende(20, "Requires V36 gadtools.library");
  254.  
  255.     CxBase = OpenLibrary("commodities.library", 36);
  256.     if(!CxBase) ende(20,"Requires V36 commodities.library");
  257.     IconBase = OpenLibrary("icon.library", 36);
  258.     if(!IconBase) ende(20,"Requires V36 icon.library");
  259.     
  260.             /*** ToolTypes (Argv) scannen ***/
  261.     
  262.     ttypes = ArgArrayInit( argc, argv );
  263.     
  264.     drive = ArgInt( ttypes, "DRIVE", 0 );
  265.     strcpy( name, ArgString(ttypes, "NAME", "Empty Disk") );
  266.     if( str=ArgString(ttypes,"FLAGS",NULL) )
  267.     {
  268.         bffs     = MatchToolValue( str, "FFS" );
  269.         bnoicons = MatchToolValue( str, "NOICONS" );
  270.         bquick   = MatchToolValue( str, "QUICK" );
  271.     }
  272.     
  273.     /* Die Texte einlesen */
  274.     LiesProgrammTexte( ArgString(ttypes,"LANGUAGEFILE","FoCo.txt") );
  275.     
  276.     /* und einsetzen */
  277.     formatreq.es_Title = TXT(0);
  278.     formatreq.es_TextFormat = TXT(1);
  279.     formatreq.es_GadgetFormat = TXT(2);
  280.     quitreq.es_Title = TXT(0);
  281.     quitreq.es_TextFormat = TXT(14);
  282.     quitreq.es_GadgetFormat = TXT(2);
  283.     mynb.nb_Name = TXT(0);
  284.     mynb.nb_Title = TXT(3);
  285.     mynb.nb_Descr = TXT(4);
  286.     
  287.             /*** Trackdisk.device öffnen: ***/
  288.     
  289.     if( !(tdport = CreateMsgPort()) )
  290.         ende(20,"Couldn't create TD MsgPort");
  291.     
  292.     /* alle 4 Units antesten */
  293.     for( i=0; i<=3; i++ )
  294.     {
  295.         if( ioexttd[i] = CreateIORequest(tdport, sizeof(struct IOExtTD)) )
  296.         {
  297.             if( OpenDevice(TD_NAME, i, ioexttd[i], TDF_ALLOW_NON_3_5) )
  298.             {
  299.                 DeleteIORequest( ioexttd[i] );
  300.                 ioexttd[i] = 0;
  301.             }
  302.             else
  303.             {
  304.                 changenum[i] = GetChangeNum(i);
  305.                 /* in Liste für CycleGadget aufnehmen */
  306.                 DiskList[dr++] = DiskName[i];
  307.             }
  308.         }
  309.     }
  310.     
  311.             /*** Hotkey installieren: ***/
  312.     
  313.     cxport = CreateMsgPort();
  314.     if(!cxport) ende(20,"Couldn't create MsgPort");
  315.     cxsigflag = 1L << cxport->mp_SigBit;    /* Signal Mask für Wait*/
  316.     mynb.nb_Port = cxport;
  317.     
  318.     /* Versuchen, den Broker zu erzeugen */
  319.     if ( !(broker = CxBroker(&mynb, NULL)) )
  320.         ende(0,0);
  321.     
  322.     /* Hotkey installieren */
  323.     AttachCxObj( broker,
  324.         HotKey( hotstr=ArgString(ttypes,"HOTKEY","lcommand f"),
  325.             cxport, POP_KEY_ID) );
  326.     
  327.     /* Disk-Insert-Filter installieren */
  328.     if( cxo = CxFilter(NULL) )
  329.     {
  330.         SetFilterIX( cxo, &diskix );
  331.         AttachCxObj( cxo, CxSender(cxport, CX_DISK_ID) );
  332.         AttachCxObj( cxo, CxTranslate(NULL) );
  333.         
  334.         AttachCxObj( broker, cxo );
  335.     }
  336.     
  337.     /* Auf summierten Fehler prüfen */
  338.     if( CxObjError(broker) )
  339.         ende(20,"Internal commodities error");
  340.     
  341.     /* Alles o.k., Broker aktivieren */
  342.     ActivateCxObj(broker,1L);
  343.     
  344.     /* soll das Fenster gleich geöffnet werden? */
  345.     if( str=ArgString(ttypes,"SHOWWINDOW",NULL) )
  346.         if( MatchToolValue(str,"ON") )
  347.             ShowWindow();
  348. }
  349.  
  350. /*------------------------------------------------------------------------*/
  351.  
  352. struct Gadget *CreateAllGadgets(
  353.     struct Gadget **glistptr, void *vi, UWORD topborder )
  354. {
  355.     struct NewGadget ng;
  356.     struct Gadget *gad;
  357.     long tl;                /* wg. cc-Fehler */
  358.  
  359.     /*  All the gadget creation calls accept a pointer to the previous
  360.         gadget, and link the new gadget to that gadget's NextGadget field.
  361.         Also, they exit gracefully, returning NULL, if any previous gadget
  362.         was NULL.  This limits the amount of checking for failure that
  363.         is needed.  You only need to check before you tweak any gadget
  364.         structure or use any of its fields, and finally once at the end,
  365.         before you add the gadgets. */
  366.  
  367.     /*  We obligingly perform the following operation, required of
  368.         any program that uses the toolkit.  It gives the toolkit a
  369.         place to stuff context data: */
  370.     gad = CreateContext(glistptr);
  371.     
  372.     /*  Fill out a NewGadget structure to describe the gadget we want
  373.         to create: */
  374.  
  375.     ng.ng_TextAttr = mysc->Font;
  376.     ng.ng_VisualInfo = vi;
  377.     
  378.     /* Längeren Label ermitteln (PropFonts!) */
  379.     tl = TextLength( rp, TXT(5), strlen(TXT(5)) );
  380.     if( TextLength( rp, TXT(6), strlen(TXT(6)) ) > tl )
  381.         tl = TextLength( rp, TXT(6), strlen(TXT(6)) );
  382.     
  383.     /* Drive: Cycler */
  384.     tl += mysc->WBorLeft + INTERWIDTH + 8;
  385.                                 /* +8 wegen Abstand Text<->Gadget */
  386.     ng.ng_LeftEdge = tl;
  387.     ng.ng_TopEdge = topborder + INTERHEIGHT;
  388.     tl = TextLength( rp, "DFX:", 3 );
  389.     ng.ng_Width = 40 + tl;                /* (26) ist das "@" plus Seitenplatz */
  390.     ng.ng_Height = mysc->Font->ta_YSize + 4;
  391.     ng.ng_Flags = NG_HIGHLABEL;
  392.     ng.ng_GadgetText = TXT(5);
  393.     ng.ng_GadgetID = GAD_DRIVE;
  394.     drivegad = gad = CreateGadget(CYCLE_KIND, gad, &ng,
  395.         GTCY_Labels, DiskList,
  396.         GTCY_Active, drive,
  397.         TAG_DONE);
  398.     
  399.     /* Name: String */
  400.     ng.ng_TopEdge += gad->Height + INTERHEIGHT;
  401.     ng.ng_Width = 22 * Xwidth;
  402.     ng.ng_Height = mysc->Font->ta_YSize + 6;    /* 2 Border + 1 freie oben&unten */
  403.     ng.ng_GadgetText = TXT(6);
  404.     ng.ng_GadgetID = GAD_NAME;
  405.     namegad = gad = CreateGadget(STRING_KIND, gad, &ng,
  406.         GTST_MaxChars, 32,
  407.         GTST_String, name,
  408.         TAG_DONE);
  409.     
  410.     WinWidth = gad->LeftEdge + ng.ng_Width + INTERWIDTH + mysc->WBorRight;
  411.         /* in ng.ng_Width sind auch die Ränder enthalten */
  412.     
  413.     /* FFS: Checkbox */
  414.     /* Checkbox-Breite: siehe gad->Width */
  415.     tl = mysc->WBorLeft + INTERWIDTH + TextLength( rp, TXT(7), strlen(TXT(7)) )+8;
  416.     ng.ng_LeftEdge = tl;
  417.     ng.ng_TopEdge += ng.ng_Height + INTERHEIGHT;
  418.     ng.ng_Height = mysc->Font->ta_YSize;
  419.     ng.ng_GadgetText = TXT(7);
  420.     ng.ng_Flags = PLACETEXT_LEFT;
  421.     ng.ng_GadgetID = GAD_FFS;
  422.     ffsgad = gad = CreateGadget(CHECKBOX_KIND, gad, &ng,
  423.         GTCB_Checked, bffs,
  424.         TAG_DONE);
  425.  
  426.     /* NoIcons: Checkbox */
  427.     tl = TextLength( rp, TXT(8), strlen(TXT(8)) )+8;
  428.     ng.ng_LeftEdge += gad->Width + 3*INTERWIDTH + tl;
  429.     ng.ng_GadgetText = TXT(8);
  430.     ng.ng_GadgetID = GAD_NOICONS;
  431.     noiconsgad = gad = CreateGadget(CHECKBOX_KIND, gad, &ng,
  432.         GTCB_Checked, bnoicons,
  433.         TAG_DONE);
  434.  
  435.     /* NoIcons: Checkbox */
  436.     tl = TextLength( rp, TXT(9), strlen(TXT(9)) )+8;
  437.     ng.ng_LeftEdge += gad->Width + 3*INTERWIDTH + tl;
  438.     ng.ng_GadgetText = TXT(9);
  439.     ng.ng_GadgetID = GAD_QUICK;
  440.     quickgad = gad = CreateGadget(CHECKBOX_KIND, gad, &ng,
  441.         GTCB_Checked, bquick,
  442.         TAG_DONE);
  443.     
  444.     tl = gad->LeftEdge + gad->Width + INTERWIDTH + mysc->WBorRight;
  445.     if( tl > WinWidth ) WinWidth = tl;
  446.     
  447.     /* OK: Button */
  448.     ng.ng_LeftEdge = mysc->WBorLeft + INTERWIDTH;
  449.     /* diese sollten etwas weiter entfernt sein */
  450.     ng.ng_TopEdge += gad->Height + mysc->Font->ta_YSize;
  451.     ng.ng_Height = mysc->Font->ta_YSize + 4;
  452.     tl = TextLength( rp, TXT(10), strlen(TXT(10)) ) + 3*INTERWIDTH;
  453.                         /* 1*INTERWIDTH deckt die beiden Ränder ab */
  454.     ng.ng_Width = tl;
  455.     ng.ng_GadgetText = TXT(10);
  456.     ng.ng_Flags = 0;
  457.     ng.ng_GadgetID = GAD_OK;
  458.     gad = CreateGadget(BUTTON_KIND, gad, &ng,
  459.         TAG_DONE);
  460.     
  461.     /* Cancel: Button */
  462.     tl = TextLength( rp, TXT(11), strlen(TXT(11)) ) + 3*INTERWIDTH;
  463.     ng.ng_Width = tl;
  464.     ng.ng_LeftEdge = WinWidth - mysc->WBorRight - INTERWIDTH - ng.ng_Width;
  465.     ng.ng_GadgetText = TXT(11);
  466.     ng.ng_GadgetID = GAD_CANCEL;
  467.     gad = CreateGadget(BUTTON_KIND, gad, &ng,
  468.         TAG_DONE);
  469.     
  470.     WinHeight = ng.ng_TopEdge + gad->Height + INTERHEIGHT - topborder;
  471.         /* bei Buttons ist gad->Height korrekt (wg.3D) */
  472.  
  473.     return(gad);
  474. }
  475.  
  476. /*-------------------------------------------------------------------------*/
  477.  
  478. void ShowWindow( void )
  479. {
  480.     if( mywin )
  481.     {
  482.         ScreenToFront( mywin->WScreen );
  483.         WindowToFront( mywin );
  484.         ActivateWindow( mywin );
  485.         GT_SetGadgetAttrs( drivegad, mywin, NULL,
  486.             GTCY_Active, drive,
  487.             TAG_END );
  488.         ActivateGadget( namegad, mywin, NULL );
  489.         return;
  490.     }
  491.     
  492.     if (!(mysc = LockPubScreen(NULL)))
  493.         return;
  494.     
  495.     /* den Default-Font des Screens bestimmen */
  496.     font = mysc->RastPort.Font;
  497.     /* Da ich TextLength() benutzen will, brauche ich den RastPort */
  498.     rp = &mysc->RastPort;
  499.     
  500.     topborder = mysc->WBorTop + (mysc->Font->ta_YSize + 1);
  501.     Xwidth = TextLength(rp,"XX",2) / 2;
  502.     
  503.     if( !(vi = GetVisualInfo(mysc, TAG_DONE)) )
  504.     {
  505.         UnlockPubScreen(NULL, mysc);
  506.         return;
  507.     }
  508.     
  509.     if( !CreateAllGadgets(&glist, vi, topborder) )
  510.     {
  511.         FreeVisualInfo(vi);
  512.         UnlockPubScreen(NULL, mysc);
  513.         return;
  514.     }
  515.     
  516.     /* Open the window: */
  517.     if( !(mywin = OpenWindowTags( NULL,
  518.         WA_Title, TXT(12),
  519.         WA_Width, WinWidth,
  520.         WA_InnerHeight, WinHeight,
  521.         WA_AutoAdjust, TRUE,
  522.         WA_PubScreen, mysc,
  523.         
  524.         WA_Activate, TRUE,
  525.         WA_DragBar, TRUE,
  526.         WA_DepthGadget, TRUE,
  527.         WA_CloseGadget, TRUE,
  528.         WA_SimpleRefresh, TRUE,
  529.         
  530.         WA_IDCMP, CLOSEWINDOW | REFRESHWINDOW |
  531.                   CYCLEIDCMP | STRINGIDCMP | CHECKBOXIDCMP,
  532.         
  533.         TAG_DONE)) )
  534.     {
  535.         FreeGadgets(glist);
  536.         FreeVisualInfo(vi);
  537.         UnlockPubScreen(NULL, mysc);
  538.         return;
  539.     }
  540.     
  541.     ScreenToFront( mywin->WScreen );
  542.     
  543.     /*  AddGadgets + Intuition-Refresh + GadTools-Refresh: */
  544.     AddGList(mywin, glist, -1, -1, NULL);
  545.     RefreshGList(glist, mywin, NULL, -1);
  546.     GT_RefreshWindow(mywin, NULL);
  547.     
  548.     windowsignal = 1 << mywin->UserPort->mp_SigBit;
  549.     ActivateGadget( namegad, mywin, NULL );
  550. }
  551.  
  552. void HideWindow( void )
  553. {
  554.     if( mywin )
  555.     {
  556.         /* Stringgadget auslesen (für nächsten CreateGadgets oder DoFormat) */
  557.         strcpy( name, ((struct StringInfo *)namegad->SpecialInfo)->Buffer );
  558.         
  559.         CloseWindow( mywin );
  560.         FreeGadgets(glist);
  561.         FreeVisualInfo(vi);
  562.         UnlockPubScreen(NULL, mysc);
  563.         
  564.         mywin = 0;
  565.         windowsignal = 0;
  566.     }
  567. }
  568.  
  569. /*------------------------------------------------------------------------*/
  570.  
  571. void ende( int code, STRPTR error )
  572. {
  573.     struct Message    *msg;
  574.     int i;
  575.     
  576.     /********** Hotkey-Cleanup... ***********/
  577.     
  578.     if(broker)
  579.     {
  580.         DeleteCxObjAll(broker);        /* safe, even if NULL    */
  581.         broker     = NULL;
  582.     }
  583.     
  584.     if(cxport)
  585.     {
  586.         /* now that messages are shut off, clear port    */
  587.         while(msg=GetMsg(cxport)) ReplyMsg(msg);
  588.         DeleteMsgPort(cxport);
  589.         
  590.         cxport     = NULL;
  591.     }
  592.     
  593.     ArgArrayDone();
  594.     
  595.     if(IconBase)    CloseLibrary(IconBase);
  596.     if(CxBase)        CloseLibrary(CxBase);
  597.     
  598.     /************ Window-Cleanup... *************/
  599.     
  600.     if (mywin)
  601.     {
  602.         CloseWindow(mywin);
  603.         FreeGadgets(glist);
  604.         FreeVisualInfo(vi);
  605.         if(mysc) UnlockPubScreen(NULL, mysc);
  606.     }
  607.     
  608.     /************ Trackdisk-Cleanup... *************/
  609.     
  610.     for( i=0; i<=3; i++ )
  611.     {
  612.         if( ioexttd[i] )
  613.         {
  614.             CloseDevice( ioexttd[i] );
  615.             DeleteIORequest( ioexttd[i] );
  616.         }
  617.     }
  618.     
  619.     if(tdport) DeleteMsgPort(tdport);
  620.     
  621.     /************ Rest... *************/
  622.     
  623.     if(TextSpeicher) FreeMem( TextSpeicher, *((long *)TextSpeicher) );
  624.     
  625.     if(GadToolsBase) CloseLibrary(GadToolsBase);
  626.     if(IntuitionBase) CloseLibrary(IntuitionBase);
  627.     if(GfxBase) CloseLibrary(GfxBase);
  628.     
  629.     if(error) Printf("Error: %s\n", error);
  630.     
  631.     exit(code);
  632. }
  633.  
  634.  
  635. /*------------------------------------------------------------------------*/
  636.  
  637. void DoFormat( void )
  638. {
  639.     char com[256];
  640.     BPTR ifh=0;
  641.     
  642.     strcpy( com, "SYS:System/Format DRIVE " );
  643.     strcat( com, DiskList[drive] );
  644.     strcat( com, " NAME \"" );
  645.     strcat( com, name );
  646.     strcat( com, "\"" );
  647.     if( bffs )        strcat( com, " FFS" );
  648.     if( bnoicons )    strcat( com, " NOICONS" );
  649.     if( bquick )    strcat( com, " QUICK" );
  650.     
  651.     if( ifh = Open(TXT(13),MODE_NEWFILE) )
  652.     {
  653.         CSystem( com,
  654.             SYS_Input, ifh,        /* wird auch als Output benutzt (s.Execute()) */
  655.             /*SYS_Output, 0,*/
  656.             SYS_Asynch, TRUE,
  657.             TAG_END );
  658.             
  659.         /* in dostags.h steht, daß input/output nach Asynchronem Lauf
  660.          * autom. geschlossen werden
  661.          * Achtung! Wenn Output() vorhanden ist, wird der benutzt und
  662.          * hinterher geschlossen --> Absturz!
  663.          */
  664.     }
  665. }
  666.  
  667. /*------------------------------------------------------------------------*/
  668.  
  669. void handleCxMsg( struct Message *msg )
  670. {
  671.     ULONG    msgid;
  672.     ULONG    msgtype;
  673.     int        d;
  674.  
  675.     msgid    = CxMsgID( msg );
  676.     msgtype = CxMsgType( msg );
  677.  
  678.     ReplyMsg( msg );
  679.  
  680.     switch( msgtype )
  681.     {
  682.         case CXM_IEVENT:
  683.             switch(msgid)
  684.             {
  685.                 case POP_KEY_ID:
  686.                 
  687.                     ShowWindow();
  688.                     break;
  689.                     
  690.                 case CX_DISK_ID:
  691.                 
  692.                     Delay( 50 );        /* Workbench soll erst ran */
  693.                     
  694.                     d = GetBADNum();
  695.                     
  696.                     if( d >= 0 )
  697.                     {
  698.                         if( EasyRequest( NULL, &formatreq, NULL, DiskName[d] ) )
  699.                         {
  700.                             for( drive=0; drive<=3 && DiskList[drive]; drive++ )
  701.                                 if( strcmp(DiskList[drive],DiskName[d])==0 )
  702.                                     break;
  703.                             if( !DiskList[drive] )
  704.                                 drive=0;
  705.                             
  706.                             ShowWindow();
  707.                         }
  708.                     }
  709.                     
  710.                     break;
  711.             }
  712.             break;
  713.             
  714.         case CXM_COMMAND:
  715.             switch(msgid)
  716.             {
  717.                 case CXCMD_DISABLE:
  718.                     ActivateCxObj(broker,0L);
  719.                     break;
  720.                 case CXCMD_ENABLE:
  721.                     ActivateCxObj(broker,1L);
  722.                     break;
  723.                     
  724.                 case CXCMD_UNIQUE:    /* Someone has tried to run us again */
  725.                 case CXCMD_APPEAR:    /* Time to pop up the window */
  726.                     /* If someone tries to run us a second time the second copy
  727.                      * of the program will fail and we will be sent a
  728.                      * CXCMD_UNIQUE message. If we support a window then we
  729.                      * Make our window appear since that is what the user wanted.
  730.                      * If we do not support a window then we kill the currently
  731.                      * running version 'this one' so that things like autopoint
  732.                      * can be toggled on/off by running them a second time.
  733.                      */
  734.                     ShowWindow();
  735.                     break;                /* the window */
  736.                 case CXCMD_DISAPPEAR:
  737.                     HideWindow();
  738.                     break;
  739.                 
  740.                 case CXCMD_KILL:
  741.                     ende(0,0);
  742.                     break;
  743.             }
  744.             break;
  745.     }
  746. }
  747.  
  748. void handleWinMsg( void )
  749. {
  750.     struct IntuiMessage *imsg;
  751.     struct Gadget *gad;
  752.     ULONG imsgClass;
  753.     UWORD imsgCode;
  754.  
  755.     while( imsg = GT_GetIMsg(mywin->UserPort) )
  756.     {
  757.         imsgClass = imsg->Class;
  758.         imsgCode = imsg->Code;
  759.         /*  Gadget vorrausgesetzt natürlich, macht aber nix... */
  760.         gad = (struct Gadget *)imsg->IAddress;
  761.         GT_ReplyIMsg(imsg);
  762.         
  763.         switch (imsgClass)
  764.         {
  765.             case GADGETUP:
  766.             case GADGETDOWN:
  767.                 switch (gad->GadgetID)
  768.                 {
  769.                     case GAD_DRIVE:
  770.                         drive = imsgCode;
  771.                         break;
  772.                     case GAD_NAME:
  773.                         strcpy( name, ((struct StringInfo *)gad->SpecialInfo)->Buffer );
  774.                         break;
  775.                     case GAD_FFS:
  776.                         bffs = gad->Flags & SELECTED;
  777.                         break;
  778.                     case GAD_NOICONS:
  779.                         bnoicons = gad->Flags & SELECTED;
  780.                         break;
  781.                     case GAD_QUICK:
  782.                         bquick = gad->Flags & SELECTED;
  783.                         break;
  784.                         
  785.                     case GAD_OK:
  786.                         HideWindow();
  787.                         DoFormat();
  788.                         return;
  789.                         break;
  790.                     case GAD_CANCEL:
  791.                         HideWindow();
  792.                         return;
  793.                         break;
  794.                 }
  795.                 ActivateGadget( namegad, mywin, NULL );
  796.                 break;
  797.             
  798.             case REFRESHWINDOW:
  799.                 GT_BeginRefresh(mywin);
  800.                 GT_EndRefresh(mywin, TRUE);
  801.                 break;
  802.             
  803.             case CLOSEWINDOW:
  804.                 if( EasyRequest(NULL, &quitreq, NULL, NULL) )
  805.                 {
  806.                     ende(0,0);
  807.                 }
  808.                 else
  809.                 {
  810.                     HideWindow();
  811.                     return;
  812.                 }
  813.                 break;
  814.         }
  815.     }
  816. }
  817.  
  818. /*------------------------------------------------------------------------*/
  819. /*------------------------------------------------------------------------*/
  820. /*------------------------------------------------------------------------*/
  821.  
  822. void main( int argc, char *argv[] )
  823. {
  824.     ULONG sigrcvd;
  825.     struct Message *msg;
  826.     
  827.     InitAll( argc, argv );
  828.     
  829.     do
  830.     {
  831.         /* auf eine Msg warten */
  832.         sigrcvd = Wait ( SIGBREAKF_CTRL_E | cxsigflag | windowsignal );
  833.         
  834.         /* Commodities-Konvention: ETK ("easy to kill") */
  835.         if( sigrcvd & SIGBREAKF_CTRL_E )
  836.             ende(0,0);
  837.         
  838.         /* Fenster... */
  839.         if( sigrcvd & windowsignal )
  840.             handleWinMsg();
  841.         
  842.         /* Msg vom Broker... */
  843.         while(cxport && (msg=GetMsg(cxport)))
  844.             handleCxMsg(msg);
  845.         
  846.     } while( 1 );
  847. }
  848.